﻿#include<iostream>
#include<string.h>
#define int long long
using namespace std;
const int N = 500007;

int cnt[N];

signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	int t;
	cin >> t;
	while (t--)
	{
		int n;
		cin >> n;
		int max_cnt = 0;
		int min_val = n + 1;
		memset(cnt, 0, sizeof(cnt));
		for (int i = 0; i < n; i++)
		{
			int val;
			cin >> val;
			min_val = min(min_val, val);
			cnt[val]++;
			max_cnt = max(max_cnt, cnt[val]);
		}
		if (cnt[min_val] == max_cnt)cout << "YES" << endl;
		else cout << "NO" << endl;
	}
	return 0;
}


//#include<iostream>
//using namespace std;
//#define int long long
//
//int v, ans;
//
//void solve(int val)
//{
//	if (val == 1)return;
//	if (val % 3 == 0)
//	{
//		val /= 3;
//		ans++;
//		solve(val);
//		return;
//	}
//	if (val % 2 == 0)
//	{
//		val /= 2;
//		ans++;
//		solve(val);
//		return;
//	}
//	if (val < v && (val + 1) % 3 == 0)
//	{
//		int d3 = (val + 1) / 3;
//		int d2 = (val - 1) / 2;
//		int d32 = v;
//		if ((val - 1) % 3 == 0)d32 = (val - 1) / 3;
//		ans += 2;
//		val = min(d3, d2);
//		val = min(val, d32);
//		solve(val);
//		return;
//	}
//	ans++;
//	solve(val - 1);
//}
//
//signed main()
//{
//	ios::sync_with_stdio(false);
//	cin.tie(0);
//	cout.tie(0);
//	int t;
//	cin >> t;
//	while (t--)
//	{
//		cin >> v;
//		ans = 0;
//		solve(v);
//		cout << ans << endl;
//	}
//	return 0;
//}


//#include<iostream>
//using namespace std;
//
//const int N = 500007;
//int arr[N];
//
//int main()
//{
//	ios::sync_with_stdio(false);
//	cin.tie(0);
//	cout.tie(0);
//	int T;
//	cin >> T;
//	char c;
//	while (T--)
//	{
//		cin >> c;
//		int pos = 0;
//		while (c != ']')
//		{
//			cin >> arr[pos++] >> c;
//		}
//		int x, y;
//		cin >> x >> y;
//		cout << '[';
//		int p = 0;
//		for (int i = 0; i < x; i++)
//		{
//			cout << '[';
//			for (int j = 0; j < y; j++)
//			{
//				if (j == y - 1)cout << arr[p];
//				else cout << arr[p] << ", ";
//				p++;
//			}
//			if (i == x - 1)cout << ']';
//			else cout << "], ";
//		}
//		cout << ']' << endl;
//	}
//	return 0;
//}

//#define _CRT_SECURE_NO_WARNINGS
//#include<iostream>
//#include<cstdio>
//using namespace std;
//
//typedef long long ll;
//ll sq[35005];
//
//int main()
//{
//	int T;
//	scanf("%d", &T);
//	for (int i = 0; i <= 35000; i++)sq[i] = i * i;
//	while (T--) {
//		ll a, b, ans = 0;
//		scanf("%lld %lld", &a, &b);
//		while (a != b) {
//			if (a > b)swap(a, b);
//			int l = 0, r = 35000, mid;
//			while (l < r) {
//				mid = (l + r) >> 1;
//				if (abs(b - a - sq[mid]) <= b - a) l = mid + 1;
//				else r = mid - 1;
//			}
//			a += sq[mid];
//			ans++;
//		}
//		printf("%lld\n", ans);
//	}
//	return 0;
//}



//#include<iostream>
//#include<algorithm>
//#include<cmath>
//using namespace std;
//typedef long long ll;
//
//int main()
//{
//	int T;
//	scanf("%d", &T);
//	while (T--)
//	{
//		ll x, a, b, ans = 0;
//		scanf("%lld %lld %lld", &x, &a, &b);
//		if (sqrt(x + b) < (x + a) / 2)
//		{
//			while (x - 1 > sqrt(x + b))
//			{
//				x = sqrt(x + b);
//				ans++;
//			}
//			while (x > a + 2)
//			{
//				x = (x + a) / 2;
//				ans++;
//			}
//		}
//		else
//		{
//			while (x > a + 2)
//			{
//				x = (x + a) / 2;
//				ans++;
//			}
//			while (x - 1 > sqrt(x + b))
//			{
//				x = sqrt(x + b);
//				ans++;
//			}
//		}
//		ans += x;
//		printf("%lld\n", ans);
//	}
//	return 0;
//}


//#include<iostream>
//#include<cstdio>
//#include<queue>
//using namespace std;
//
//const int N = 1000007;
//
//struct Val
//{
//	int val, pos;
//	bool operator<(const Val& v)const {
//		return val < v.val;
//	}
//	bool operator>(const Val& v)const {
//		return val > v.val;
//	}
//};
//
//int cnt[N];
//
//int main()
//{
//	int T;
//	scanf("%d", &T);
//	while (T--) {
//		int n, nn;
//		Val val;
//		priority_queue<Val, vector<Val>, greater<Val>>qu1;
//		priority_queue<Val, vector<Val>, less<Val>>qu2;
//		scanf("%d", &n);
//		for (int i = 1; i <= n; i++) {
//			scanf("%d", &nn);
//			cnt[i] = nn;
//			while (nn--) {
//				scanf("%d", &val.val);
//				val.pos = i;
//				qu1.push(val);
//				qu2.push(val);
//			}
//		}
//		while (qu1.size() > 1 && cnt[qu1.top().pos] > 1) {
//			Val top = qu1.top();
//			qu1.pop();
//			cnt[top.pos]--;
//		}
//		while (qu2.size() > 1 && cnt[qu2.top().pos] > 1) {
//			Val top = qu2.top();
//			qu2.pop();
//			cnt[top.pos]--;
//		}
//		printf("%d\n", qu2.top().val - qu1.top().val);
//	}
//	return 0;
//}

//#include<iostream>
//#include<cstdio>
//#include<algorithm>
//#include<string.h>
//#include<queue>
//using namespace std;
//
//const int N = 100007;
//typedef long long LL;
//
//struct Stone
//{
//	LL a, b;
//	int order;
//};
//
//bool vis[N];
//int cnt;
//LL ans_a, ans_b;
//
//struct cmp_a
//{
//	bool operator()(const Stone& s1, const Stone& s2) const {
//		if (s1.a - s2.b != s2.a - s1.b)return s1.a - s2.b < s2.a - s1.b;
//		return s1.a < s2.a;
//	}
//};
//
//struct cmp_b
//{
//	bool operator()(const Stone& s1, const Stone& s2) const {
//		if (s1.b - s2.a != s2.b - s1.a)return s1.b - s2.a < s2.b - s1.a;
//		return s1.b < s2.b;
//	}
//};
//
//priority_queue<Stone, vector<Stone>, cmp_a>qa;
//priority_queue<Stone, vector<Stone>, cmp_b>qb;
//
//void pick(int choose)
//{
//	if (choose) {
//		while (!qa.empty() && vis[qa.top().order])qa.pop();
//		if (qa.empty())return;
//		Stone top = qa.top();
//		qa.pop();
//		vis[top.order] = true;
//		ans_a += top.a;
//		pick(0);
//	}
//	else {
//		while (!qb.empty() && vis[qb.top().order])qb.pop();
//		if (qb.empty())return;
//		Stone top = qb.top();
//		qb.pop();
//		vis[top.order] = true;
//		ans_b += top.b;
//		pick(1);
//	}
//}
//
//int main()
//{
//	int T;
//	scanf("%d", &T);
//	while (T--) {
//		memset(vis, false, sizeof(vis));
//		ans_a = ans_b = 0;
//		scanf("%d", &cnt);
//		Stone val;
//		for (int i = 1; i <= cnt; i++) {
//			scanf("%lld %lld", &val.a, &val.b);
//			val.order = i;
//			qa.push(val);
//			qb.push(val);
//		}
//		pick(1);
//		printf("%lld\n", ans_a - ans_b);
//	}
//	return 0;
//}

//#include<iostream>
//#include<cstdio>
//#include<map>
//using namespace std;
//
//typedef long long LL;
//typedef pair<LL, LL> pii;
//
//map<pii, int>mp;
//
//void add(LL& a, LL& b)
//{
//	if (a > b) {
//		while (a > 0) {
//			mp[make_pair(a, b)]++;
//			a -= b;
//		}
//		a += b;
//	}
//	else {
//		while (b > 0) {
//			mp[make_pair(a, b)]++;
//			b -= a;
//		}
//		b += a;
//	}
//	if (a == 1 || b == 1 || a == b)return;
//	mp[make_pair(a, b)]--;
//	add(a, b);
//}
//
//int main()
//{
//	int T;
//	scanf("%d", &T);
//	while (T--)
//	{
//		int n, q;
//		map<pii, int>().swap(mp);
//		scanf("%d %d", &n, &q);
//		for (int i = 0; i < n; i++)
//		{
//			LL a, b;
//			scanf("%lld %lld", &a, &b);
//			add(a, b);
//		}
//		while (q--)
//		{
//			LL a, b = 0;
//			scanf("%lld %lld", &a, &b);
//			int ans = mp[make_pair(a, b)];
//			printf("%d\n", ans);
//		}
//	}
//	return 0;
//}


//#include<iostream>
//#include<cstdio>
//using namespace std;
//
//const int N = 1e5 + 10;
//typedef long long LL;
//
//int main()
//{
//	LL T;
//	scanf("%lld\n", &T);
//	while (T--)
//	{
//		LL len, cnt;
//		scanf("%lld %lld\n", &len, &cnt);
//		char arr[N];
//		scanf("%s", arr);
//		string s(arr);
//		int flag = 0, f = 0;
//		if (s.find("11") != -1 || s.find("00") != -1)
//		{
//			flag = 1;
//		}
//		for (int i = 0; i < s.length(); i++)
//		{
//			f = 0;
//			while (s[i] == '0' && cnt)
//			{
//				s[i] = '1';
//				i++;
//				f = 1;
//			}
//			if (f)
//			{
//				cnt--;
//			}
//		}
//		if (cnt == 1 && !flag)
//		{
//			s[len - 1] = '0';
//		}
//		printf("%s\n", s.c_str());
//	}
//	return 0;
//}


//#include<iostream>
//#include<cstdio>
//using namespace std;
//
//const int N = 100007, X = 131;
//typedef unsigned long long ULL;
//ULL hash_code[N];
//
//int main()
//{
//	int T;
//	scanf("%d", &T);
//	while (T--)
//	{
//		int m, n, q;
//		scanf("%d %d", &n, &m);
//		for (int i = 1; i <= n; i++)
//		{
//			char val[N];
//			scanf("%s", val + 1);
//			//复制一次
//			for (int j = 1; j <= m; j++)
//			{
//				val[m + j] = val[j];
//			}
//			//找到最小表示法的位置
//			//通过比较两个子串找到更合适的
//			int p1 = 1, p2 = 2, k = 0;
//			while (p1 <= m && p2 <= m)
//			{
//				//相同的跳过
//				for (k = 0; k < m && val[p1 + k] == val[p2 + k]; k++);
//				/*if (k == m)
//				{
//					break;
//				}*/
//				if (val[p1 + k] > val[p2 + k])
//				{
//					p1 = p1 + k + 1;
//				}
//				else
//				{
//					p2 = p2 + k + 1;
//				}
//				if (p1 == p2)
//				{
//					//比较的两个子串不能是相同的
//					p1++;
//				}
//			}
//			int pos = min(p1, p2);
//			//计算该子串的哈希值(即该字符串的最小表示值)
//			hash_code[i] = val[pos];
//			for (int j = pos + 1; j < pos + 1 + m; j++)
//			{
//				hash_code[i] = hash_code[i] * X + val[j];
//			}
//		}
//		scanf("%d", &q);
//		while (q--)
//		{
//			int a, b;
//			scanf("%d %d", &a, &b);
//			if (hash_code[a] == hash_code[b])
//			{
//				printf("Yes\n");
//			}
//			else
//			{
//				printf("No\n");
//			}
//		}
//	}
//	return 0;
//}




//#define _CRT_SECURE_NO_WARNINGS
//#include<iostream>
//#include<string.h>
//#include<cstdio>
//#include<vector>
//using namespace std;
//
//const int N = 100007, X = 131;
//typedef unsigned long long ULL;
//ULL hash_code[N], xn[N];
//vector<vector<ULL>>double_hash_code;
//
//int main()
//{
//	int T;
//	scanf("%d", &T);
//	xn[0] = 1;
//	for (int i = 1; i < N; i++)
//	{
//		xn[i] = xn[i - 1] * X;
//	}
//	while (T--)
//	{
//		int m, n, q;
//		scanf("%d %d", &n, &m);
//		vector<vector<ULL>>().swap(double_hash_code);
//		double_hash_code.push_back({});
//		for (int i = 1; i <= n; i++)
//		{
//			char cval[N];
//			scanf("%s", cval);
//			string val(cval);
//			hash_code[i] = val[0];
//			for (int j = 1; j < val.length(); j++)
//			{
//				hash_code[i] = hash_code[i] * X + val[j];
//			}
//			string dval = val + val;
//			vector<ULL>arr;
//			arr.resize(2 * m);
//			arr[0] = dval[0];
//			for (int j = 1; j < dval.length(); j++)
//			{
//				arr[j] = arr[j - 1] * X + dval[j];
//			}
//			double_hash_code.push_back(arr);
//		}
//		scanf("%d", &q);
//		while (q--)
//		{
//			int a, b;
//			scanf("%d %d", &a, &b);
//			int flag = 1;
//			for (int pos = 0; pos + m - 1 < 2 * m; pos++)
//			{
//				if ((pos ? double_hash_code[a][pos + m - 1] - double_hash_code[a][pos - 1] * xn[m] : double_hash_code[a][pos + m - 1]) == hash_code[b])
//				{
//					printf("Yes\n");
//					flag = 0;
//					break;
//				}
//			}
//			if (flag)
//			{
//				printf("No\n");
//			}
//		}
//	}
//	return 0;
//}

//#define _CRT_SECURE_NO_WARNINGS
//#include<iostream>
//#include<cstdio>
//using namespace std;
//
//typedef long long LL;
//
//int main()
//{
//	LL T;
//	scanf("%lld", &T);
//	while (T--)
//	{
//		LL a, b, d;
//		scanf("%lld %lld %lld", &a, &b, &d);
//		LL div = b / a;
//		if (div > d - 1 || (div == d - 1) && (b % a))
//		{
//			printf("Yes\n");
//		}
//		else
//		{
//			printf("No\n");
//		}
//	}
//	return 0;
//}

//#include<iostream>
//#include<vector>
//#include<cmath>
//#include<algorithm>
//using namespace std;
//
//vector<int> div(vector<int>& A, int b, int& r)
//{
//	vector<int> C;
//	r = 0;
//	for (int i = A.size() - 1; i >= 0; i--)
//	{
//		r = r * 10 + A[i];
//		C.push_back(r / b);
//		r %= b;
//	}
//	reverse(C.begin(), C.end());
//	while (C.size() > 1 && C.back() == 0) C.pop_back();
//	return C;
//}
//
//int main()
//{
//	int T;
//	cin >> T;
//	while (T--)
//	{
//		vector<int> a, ans;
//		int b, r, d;
//		cin >> b;
//		string s;
//		cin >> s;
//		for (int i = s.length() - 1; i >= 0; i--)
//		{
//			a.push_back(s[i] - '0');
//		}
//		cin >> d;
//		ans = div(a, b, r);
//		int res = 0;
//		for (int i = 0; i < ans.size(); i++)
//		{
//			res += ans[i] * pow(10, i);
//		}
//		if (res > d - 1 || (res == d - 1 && r > 0))
//		{
//			cout << "Yes" << endl;
//		}
//		else
//		{
//			cout << "No" << endl;
//		}
//	}
//	return 0;
//}

//#include<iostream>
//#include<string.h>
//#include<vector>
//using namespace std;
//
//const int N = 100007;
//
//int* findNext(string P)
//{
//	int i, k;
//	int m = P.length();
//	int* next = new int[m];
//	next[0] = -1;
//	i = 0; k = -1;
//	while (i < m - 1)
//	{
//		while (k >= 0 && P[k] != P[i])
//			k = next[k];
//		i++;
//		k++;
//		if (P[k] == P[i])
//			next[i] = next[k];
//		else
//			next[i] = k;
//	}
//	return next;
//}
//
//int KMPStrMatching(string T, string P, int* N)
//{
//	int i = 0;
//	int j = 0;
//	int tLen = T.length();
//	int pLen = P.length();
//	if (tLen < pLen)
//	{
//		return -1;
//	}
//	while (i < tLen && j < pLen)
//	{
//		if (j == -1 || T[i] == P[j])
//			i++, j++;
//		else j = N[j];
//	}
//	if (j >= pLen)
//	{
//		return (i - pLen);
//	}
//	else
//	{
//		return -1;
//	}
//}
//
//int main()
//{
//	int T;
//	cin >> T;
//	while (T--)
//	{
//		int m, n, q;
//		vector<string>arr;
//		cin >> n >> m;
//		for (int i = 1; i <= n; i++)
//		{
//			string val;
//			cin >> val;
//			arr.push_back(val);
//		}
//		cin >> q;
//		while (q--)
//		{
//			int a, b;
//			cin >> a >> b;
//			string fir = arr[a - 1] + arr[a - 1];
//			int* nex = new int[100];
//			nex = findNext(arr[b - 1]);
//			if (KMPStrMatching(fir, arr[b - 1], nex) != -1)
//			{
//				cout << "Yes" << endl;
//			}
//			else
//			{
//				cout << "No" << endl;
//			}
//		}
//	}
//	return 0;
//}